Augmented intelligence for creating software development artifacts

ABSTRACT

Embodiments disclose systems and methods for generating source code. One or more application specific inputs and one or more external inputs are received. Using a machine learning model, source code is automatically generated based on the one or more application specific inputs and the one or more external inputs. The source code can embody the one or more application specific inputs and the one or more external inputs. One or more revisions to the automatically generated source code may be made, and a difference determined between the generated source code and the revised source code. The machine learning model may be further trained to generate a future source code based on the differences it determines.

CROSS-REFERENCE TO RELATED APPLICATIONS

This application is continuation of U.S. application Ser. No.17/189,326, filed on Mar. 2, 2021, the entirety of which is incorporatedby reference herein.

TECHNICAL FIELD

Embodiments relate to artificial intelligence systems, specificallyartificial intelligence systems for generating source code.

BACKGROUND

When developing software, many rules and constraints have to be adheredto. These rules and constraints include, at least, application specificrequirements and corporate rules and/or guidelines for developingsoftware code. These rules and/or guidelines should remain consistentacross applications. As a result, source code developed should result inconsistent, and oftentimes redundant or highly similar, source codeacross applications. Current systems and methods for developingsoftware, however, have shortcomings when it comes to allowing softwaredevelopers to efficiently incorporate redundant or highly similar sourcecode from other applications into their own applications. Often,software developers are not aware that the code they are writing mayhave been previously written, leading to duplication of efforts. Othertimes, software developers use different design strategies that resultin incompatibility between systems. Systems and methods are needed toaddress these problems.

SUMMARY

Embodiments disclosed herein provide artificial intelligence systemsthat perform methods for the generation of source code. The systems andmethods improve conventional systems by enabling the automation ofsource code generation, and as a result increase efficiency whendeveloping software, reduce duplication of efforts, and increaseuniformity of source code. In embodiments, the systems can performmethods to receive one or more application specific inputs and one ormore external inputs. In embodiments, the systems further automaticallygenerate, with a machine learning model, source code based on the one ormore application specific inputs and the one or more external inputs. Inembodiments, the source code can embody the one or more applicationspecific inputs and the one or more external inputs. In embodiments, thesystems can further receive, by the one or more computing devices, oneor more revisions to the source code automatically generated anddetermine a difference between the source code generated and the sourcecode revised. In embodiments, the systems can further train, by the oneor more computing devices, the machine learning model to generate afuture source code based on the difference.

Certain embodiments of the invention have other steps or elements inaddition to or in place of those mentioned above. The steps or elementswill become apparent to those skilled in the art from a reading of thefollowing detailed description when taken with reference to theaccompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

The accompanying drawings, which are incorporated herein and form a partof the specification, illustrate embodiments of the present disclosureand, together with the description, further serve to explain theprinciples of the disclosure and to enable a person skilled in thepertinent art to make and use the disclosure.

FIG. 1 is a system for automatically generating source code in anembodiment of the present disclosure.

FIG. 2 is an example control flow of an AI module in an embodiment ofthe present disclosure.

FIG. 3 is an example method of operating the system in an embodiment ofthe present disclosure.

FIG. 4 is an example architecture of the components implementing thesystem in an embodiment of the present disclosure.

DETAILED DESCRIPTION

Systems and methods are needed to allow software developers to leverageand develop highly similar source code across applications. Embodimentsdisclosed herein relate to a system and method that recognizeapplication specific requirements and corporate rules and/orconstraints, and based on the same, gain insight as to what source codeshould be generated. The system and method can further generate sourcecode based on past models in addition to given rules and constraints fora software application, and further generate source code that isredundant across applications. The system and method can alsoautomatically modify the source code for application specificrequirements. Current systems lack the ability to perform thesefunctions.

Embodiments disclosed herein can receive, by one or more computingdevices, one or more application specific inputs and one or moreexternal inputs. Using a machine learning model, source code isautomatically generated based on the one or more application specificinputs and the one or more external inputs. The source code can embodythe one or more application specific inputs and the one or more externalinputs. One or more revisions to the automatically generated source codeare received, and a difference is determined between the generatedsource code and the revised source code. The machine learning model mayfurther be trained to generate a future source code based on thedifferences it determines.

The following embodiments are described in sufficient detail to enablethose skilled in the art to make and use the disclosure. It is to beunderstood that other embodiments are evident based on the presentdisclosure, and that system, process, or mechanical changes may be madewithout departing from the scope of an embodiment of the presentdisclosure.

In the following descriptions, numerous specific details are given toprovide a thorough understanding of the disclosure. However, it will beapparent that the disclosure may be practiced without these specificdetails. In order to avoid obscuring an embodiment of the presentdisclosure, some well-known circuits, system configurations,architectures, and process steps are not disclosed in detail.

The drawings showing embodiments of the system are semi-diagrammatic,and not to scale. Some of the dimensions are for the clarity ofpresentation and are shown exaggerated in the drawing figures.Similarly, although the views in the drawings are for ease ofdescription and generally show similar orientations, this depiction inthe figures is arbitrary for the most part. Generally, the disclosuremay be operated in any orientation.

The term “module” or “unit” referred to herein may include software,hardware, or a combination thereof in an embodiment of the presentdisclosure in accordance with the context in which the term is used. Forexample, the software may be machine code, firmware, embedded code, orapplication software. Also for example, the hardware may be circuitry, aprocessor, a special purpose computer, an integrated circuit, integratedcircuit cores or a combination thereof. Further, if a module or unit iswritten in the system or apparatus claims section below, the module orunit is deemed to include hardware circuitry for the purposes and thescope of the system or apparatus claims.

The modules or units in the following description of the embodiments maybe coupled to one another as described or as shown. The coupling may bedirect or indirect, without or with intervening items between coupledmodules or units. The coupling may be by physical contact or bycommunication between modules or units.

System Overview and Function

FIG. 1 shows a system 100 for automatically generating source code 102in an embodiment of the present disclosure. In a variety of embodiments,the system 100 may be part of a backend computing infrastructure,including a server infrastructure of a company or institution. In avariety of embodiments, the system 100 may be used while developingsoftware applications. For example, if a development team 118 (i.e., agroup of software developers) is tasked with developing a softwareapplication, the system 100 may be used to assist the development team118 in automatically generating portions of source code 102 for thesoftware application.

In a variety of embodiments, the system 100 may be implemented withmodules and sub-modules. For example, the system 100 may include an AImodule 104. The AI module 104 can implement a machine learning modelused to generate the source code 102 based on one or more inputs. Howthe machine learning model operates will be described further below. Theinputs may include variables, parameters, conditional statements,software templates, or a combination thereof, that together representthe constraints of the software application being developed and therules of the company or institution for developing the softwareapplication.

In a variety of embodiments, the inputs may include application specificinputs 106, external inputs 108, revisions 110, and production inputs112. Based on the inputs, the AI module 104 can generate one or moreoutputs 114. The outputs 114 can include at least the source code 102.The source code 102 can embody some or all of the inputs. For example,the source code 102 can embody or implement the rules or constraints ofthe software application being developed. How the AI module 104generates the outputs 114 will be discussed further below.

The application specific inputs 106 refer to inputs representingvariables, rules, constraints, or other requirements of the softwareapplication to be developed. For example, the application specificinputs 106 can include application requirements 122 and dependencies124. The application requirements 122 refer to application specificfeatures and can include the features and functions that the softwareapplication must implement or perform. For example and withoutlimitation, the application requirements 122 can include thedescriptions of the specific interfaces the software application musthave; the memory allocation and usage requirements for the softwareapplication; the classes, methods, or functions the software applicationmust implement or use; safety and security requirements of the softwareapplication; what programming languages the software should beimplemented in; etc. The dependencies 124 refer to inputs representingwhat components, systems, or other software or hardware the softwareapplication depends on, or must interface with, to perform itsfunctions. For example and without limitation, the dependencies 124 caninclude descriptions or parameters indicating the hardware componentsthe software application must interface with; what other softwareapplications or application programming interfaces (APIs) the softwareapplication must interface with; what external systems the softwareapplication must interface with; etc.

Continuing with the example, in a variety of embodiments, theapplication specific inputs 106 may be obtained from computer readabledata files, such as a text file or an extensible markup language (XML)data file, Javascript object notation (JSON), a YML data file, or from arepository or storage location storing the application specific inputs106. In a variety of embodiments, the application specific inputs 106may be transmitted to the AI module 104 from the computer readable datafile, the repository, or the storage location, for further processing bythe AI module 104. In a variety of embodiments, the application specificinputs 106 can further be input directly into the AI module 104 by thedevelopment team 118. For example, the development team 118 can inputthe application specific inputs 106 via a developer interface 120, forexample an API or web interface.

The external inputs 108 refer to inputs representing rules, constraints,thresholds, standards, requirements, or a combination thereof requiredby the company or institution for developing software applications. Theexternal inputs 108 can represent the internal policies, rules, orconstraints placed on the development of software applications so thatthe software applications work with, and conform to, the systems andinfrastructure of the company or institution. The external inputs 108can include a variety of inputs, including, for example and withoutlimitation: development artifacts 126, business metrics 130, bestpractice parameters 132, design pattern parameters 140, resiliencyparameters 142, configuration and services integration parameters 146,cyber security parameters 148, or observability parameters 150.

Development artifacts 126 refer to existing software code orconfigurations that have been implemented, written, or generated tosupport existing applications or systems of the company or institutionthat the software application being developed must be compatible with.For example, the development artifacts 126 can be code and/orconfigurations that implement security measures or processes that mustbe integrated into any software application being developed by thecompany or institution.

Business metrics 130 refer to business constraints (i.e., businessrules) that must be adhered to by all software applications developedfor the company or institution. For example, if the software applicationis being developed to facilitate financial transactions, the businessmetrics 130 can include conditions, thresholds, or parametersindicating, for example, the maximum amount of time in whichtransactions are to be completed, customer guarantees for the categoriesof transactions (e.g., no fees charged on transactions below a certainthreshold value, etc.), maximum or minimum thresholds that may betransacted on, rules related to certain categories of transactions(e.g., rules related to transfers to foreign countries vs. domestictransfers), etc. The business metrics 130 can also include conditions,thresholds, or parameters indicating baseline business related minimumrequirements that the software application must adhere to in order toprovide a required performance or user experience for customers, users,or the system overall. For example, business metrics 130 can furtherinclude conditions, thresholds, or parameters indicating a minimum ormaximum number of users the software application must support, whatresponse times the software application must adhere to, the minimumdowntime the software application can have, etc. to provide an adequateuser experience and/or perform to company or institution standards andbusiness guarantees to users or customers.

Best practices parameters 132 refer to policies developed by the companyor institution that indicate best practices in developing softwareapplications. For example, these can include formatting guidelines forcode, naming conventions, file or folder structure guidelines, etc.

Design pattern parameters 140 refer to code specific design patterns orformats that are used by the company or institution when designingsoftware code for applications so the software code can adapt andintegrate into the existing company or institution systems andinfrastructure. Examples of design pattern parameters 140 includeclasses, software wrappers, etc. implementing code specific designpatterns or formats for software, such as Adapter, Facade, Prototype,Strategy, Abstract, Singleton, Observer, Factory, etc. Theaforementioned are examples of design patterns or formats known in theart for developing software, and implement formalized best practices forclass structures, API conventions, how classes interface with oneanother, etc., that a software developer can use to solve commonproblems when designing an application or system.

Resiliency parameters 142 refer to conditions or rules regarding how thesoftware application is to behave to prevent it from crashing. Theresiliency parameters 142 can indicate how the software application isable to auto failover and recover during disaster situations, such aspower outages, infrastructure failures, etc., and to what systems thesoftware application is to failover to in order to continue performingits functions.

Configuration and services integration parameters 146 refer toconfigurations or settings the software must have pre-coded in order forthe software application to integrate into existing systems of thecompany or institution. For example, these can be uniform resourcelocators (URLs) to repositories, webpages, or databases where thesoftware application can obtain the data it needs to perform itsfunctions, or URLs to locations where the software application canoutput data it generates.

Cyber security parameters 148 refer to cyber security standards or rulesdefined by the company or institution that the software application mustadhere to. These include rules and limits on resources or sources thatthe software application can access, what permissions the softwareapplication has to access resources, etc.

Observability parameters 150 refer to parameters or metrics indicatingthe overall status of company or institution systems and infrastructure.The observability parameters 150 can indicate overall system behavior,provide network/event tracing, provide status information regarding CPU,memory utilization, network utilization, disk space usage, etc., provideinformation on failures or potential failures, and provide applicationlogs of events. The software application can use the observabilityparameters 150 to obtain feedback regarding the company or institutionenvironment or systems so as to inform some of its own functionality,for example, what functions to trigger in the event of a system failureor degradation.

Continuing with the example, in a variety of embodiments, the externalinputs 108 may be integrated into software templates 138 that may beinput into the AI module 104. In other words, the software templates 138can implement the external inputs by, for example, implementing therules, constraints, variables, or parameters of the external inputs 108into a pre-written code. The software templates 138 may be used to trainthe AI module 104 on how to generate the source code 102. The softwaretemplates 138 refer to models of pre-written software code. For example,the software templates 138 may include pre-written code implementingcertain functions that are commonly used across software applications,and that take into account the requirements and constraints of theexternal inputs 108. In this way, the corporation or institutionpolicies and requirements regarding software development may be takeninto account by the AI module 104 when automatically generating thesource code 102.

The software templates 138 may be optimized and tested to ensure theirfunctionality and compatibility with the company or institution backendsystems and infrastructure. The functions of the software templates 138can vary and can include, for example and without limitation, functionsrelated to searching or retrieving data, or functions such as creatingcertain interfaces or generating certain variables, parameters, oroutputs used across software applications, functions related to securitypolicies for software applications, etc.

In a variety of embodiments, the AI module 104 may be trained to copy,modify, or derive pre-written code from the software templates 138, toimplement certain functions of the software application being developed.For example, if the software application being developed is required toperform a certain function, for example searching for a certain piece ofdata, the AI module 104 may be trained to copy, modify, or derivepre-written code from any of the software templates 138 that perform thesame function. In a variety of embodiments, this may be done, forexample, by training the AI module 104 to search for the softwaretemplates 138 based on their functions and copying, modifying, orderiving the pre-written code from the software templates 138 into thefuture source code generated by the AI module 104. In a variety ofembodiments, this may also be done by training the AI module 104 torecognize patterns, using machine learning classifier architectures, forexample neural networks, linear classifiers, nearest neighbor, supportvector machines, decision trees, boosted trees random forest, etc., tomatch application specific inputs 106 and/or production inputs 112 tothe software templates 138 in order to derive the source code 102.

By way of example, in a variety of embodiments, the AI module 104 canperform a search for the software templates 138 via a table lookup,where pre-existing tables exist that may be used to map the desiredfunction of the software application being developed via the applicationspecific inputs 106, to the software templates 138. The mapping may beperformed by matching the application specific inputs 106 todescriptions or parameters indicating what functions the softwaretemplates 138 perform. In a variety of embodiments, the descriptions orparameters can be entries in the pre-existing tables. In a variety ofembodiments, the pre-existing tables may be pre-generated and may bestored in a storage location or repository for searching. In a varietyof embodiments, the AI module 104 can perform the search by comparingthe parameters or descriptions associated with the software templates138 to the application specific inputs 106 to determine if any of thesoftware templates 138 exist that perform the same functions required asindicated by the application specific inputs 106. For example, this canbe done by parsing a textual description of the software templates 138,as indicated by the descriptions or parameters, and determining, basedon using a natural language processing (NLP) method, what functions thesoftware templates 138 perform. If a software template is found matchingthe application specific inputs 106, the software template can be usedto generate the source code 102.

By way of example, if the application specific inputs 106 require thesoftware application to have a button, where if the button is pressed anemail is generated, the AI module 104 can search for software templates138 implementing such a function. If an exact match is found amongst thesoftware templates 138, the AI module 104 can copy, emulate, or derivethe pre-written code from the matching software templates 138 togenerate the source code 102.

In a variety of embodiments, if an exact match is not found, the AImodule 106 can further be trained to generate a source code 102 highlysimilar to the desired function. This may be done by, for example,searching for software templates 138 via the table lookup, and searchingfor the software templates 138 with parameters or descriptions thatoverlap or partially match with the desired functionality. Take theexample where the application specific inputs 106 require the softwareto have a button, where the button contacts a specific vendor whenpressed. In this example, assume no software templates 138 exist withsuch functionality, but software templates 138 exist for buttons that,when pressed, access databases. In such a scenario, the AI module 104can copy, emulate, or derive pre-written code from the softwaretemplates 138 for buttons that when pressed access databases.

In a variety of embodiments, if the source code 102 generated as theequivalent does not meet the needs of the development team 118, thedevelopment team 118 can further modify (i.e., revise) the generatedsource code 102 to further customize the source code 102 to perform thespecific desired function. As used in this disclosure, the modificationswill be referred to as revisions 110. The revisions 110 can further besaved to a storage location or repository. The revisions 110 may furtherbe added to the software templates 138 and/or added as new softwaretemplates used to train the AI module 104. The new software templatesmay then be used to generate future source code such that when futuresoftware applications are to be developed implementing functions similarto the revised source code, the revised source code can subsequently beused by the AI module 104 to generate a source code 102. The revisions110 will be discussed further below.

In a variety of embodiments, the AI module 104 can use machine learningclassifier architectures to perform its functions. In embodiments, theclassifier architectures can be used to recognize patterns in order tomatch the application specific inputs 106 and/or the production inputs112 to the software templates 138. Based on the matching, the sourcecode 102 can be derived from the software templates 138. In a variety ofembodiments, if for example the machine learning classifier architectureis a neural network, the AI module 104 can implement the neural networksto receive the application specific inputs 106 and/or the productioninputs 112, and pass these inputs through successive linear layers.Based on passing the inputs through the successive layers, patterns ofspecific input sequences can be matched to software templates 138. Thesoftware templates 138 can then be returned as the source code 102.Similarly, the same principles can be applied and implemented usingother machine learning classifier architectures.

In embodiments, the machine learning classifier architectures can betrained to recognize patterns over a period of time through supervisedtraining methods. In a variety of embodiments, the training methods cantrain the machine learning classifier architectures to match specificinput pattern sequences to specific software templates 138. By way ofexample, and taking the example where the application specific inputs106 require the software to have a button and the button contacts aspecific vendor when pressed, the application specific inputs 106 forthis type of functionality can have a specific pattern. For example, ina variety of embodiments, certain variables, classes, objects, etc. canbe defined and passed to the AI module 104, as the application specificinputs 106, indicating that such a functionality is required for thesoftware application being developed. Based on its training, the machinelearning classifier architectures of the AI module 104 can receive theseinputs and map them to software template 138. For example, inembodiments where the machine learning classifier architectures areneural networks, the AI module 104 can receive these inputs and passthem through successive linear layers, which via various pre-determinedweights and biases, can be mapped to software templates 138.

As indicated, the training can be done via supervised training methods.Supervised training methods refer to machine learning tasks wheremachines can be taught to map an input to an output based on exampleinput-output pairs. In a variety of embodiments, the supervised trainingcan proceed by feeding the machine learning classifier architecturesvarious input patterns of application specific inputs 106 and/orproduction inputs 112, and attempt to match these input patterns tosoftware templates 138. Based on the how the machine learning classifierarchitectures match the input patterns to the software templates 138,the machine learning classifier architectures can be given feedback. Thefeedback can be via the development team 118 (optionally the developmentteam 118 may have their own dedicated machine learning models (e.g.,reinforcement, unsupervised, etc.) to evaluate the output and providethe feedback), or other individuals training the machine learningclassifier architectures. The feedback can indicate whether the machinelearning classifier architectures matched the input patterns to thecorrect software templates 138. In a variety of embodiments, thisprocess can be performed over a period of time, to train the machinelearning classifier architectures to recognize which input patternsmatch to what software templates 138. In embodiments where the machinelearning classifier architectures are neural networks, as a part of thetraining process, weights and biases connecting the linear layers of theneural network can be tuned based on the feedback. The weights andbiases refer to values that provide multipliers for the computationsperformed by the neural networks to give greater or lesser weight tocertain outcomes of computations of the neural network. The tuning ofthe weights and biases allows the neural networks to better map futureinput patterns for similar functions to the software templates 138implementing those functions. Similarly, in embodiments where othermachine learning classifier architectures are used, similar weights,biases, or other similar tuning parameters can be used to tune forand/or generate specific outputs.

In embodiments, the tuning can be performed via various methods. Forexample, in embodiments where the machine learning classifierarchitectures are neural networks, the tuning can be performed via across entropy loss function performed on the output of the neuralnetwork to determine the difference between the output of the neuralnetwork and the desired outcome (in this case the correct match to thesoftware templates 138). Based on the difference, the weights and biasescan be adjusted to better achieve the desired outcome for future inputs.In other embodiments, the tuning can be performed using logisticregression, conditional entropy, maximum likelihood estimation, etc.depending on the machine learning classifier architecture used.

Continuing with the example, in a variety of embodiments, the softwaretemplates 138 implementing and incorporating the rules and constraintsof the external inputs 108, similar to the application specific inputs106, may be obtained from a repository or storage location where thesoftware templates 138 are stored. In a variety of embodiments, thesoftware templates 138 may be transmitted to the AI module 104 via thestorage location or repository, and may be used for further processingby the AI module 104 and to train the AI module 104.

The production inputs 112 refer to inputs representing rules,constraints, thresholds, requirements, or a combination thereofdeveloped or put in place based on the performance of existing softwareapplications running on a company or institution production environment.The production environment refers to a setting where softwareapplications are put into operation for their intended use by end users,rather than for testing. For example, the production inputs 112 caninclude at least production metrics 154.

Production metrics 154 refer to variables or parameters used to measureperformance of software applications on company or institution backendsystems or infrastructure. The production metrics 154 may be used by theAI module 104 to determine constraints of the backend systems andinfrastructure, and the limitations of these systems. In a variety ofembodiments, based on the production metrics 154, the AI module 104 cangenerate the source code 102 or future source code, to meet theconstraints and limitations of the backend systems and infrastructure.For example and without limitation, the production metrics 154 caninclude variables or parameters regarding a network utilization byapplications, processing resource utilization by applications, networktraffic due to applications, error rates due to applications, bugsreported based on applications, uptime for applications, etc.

In a variety of embodiments, the AI module 104 can generate the sourcecode 102 or future source code based on the production metrics 154.Moreover, in a variety of embodiments, the AI module 104 may be trainedto learn patterns of the production metrics 154 to determine trendsrelated to the company or institution backend systems. Based on thetrends, the AI module 104 can generate the source code 102. For example,in a variety of embodiments, if the trends indicate that network trafficis on a downward trend (i.e., the network has extra capacity for datatransfers), the AI module 104 can, for example, generate source code 102that does not constrain or limit how the software application callssources of data that it may need as inputs. On the other hand, if thenetwork does not have extra capacity for data transfers, the AI module104 can, for example, generate source code 102 that limits how manycalls a software application makes to sources of data. For example, ifthere is a choice to obtain data from systems external to company orinstitution systems and infrastructure or from sources where such datais cached but internal to company or institution systems andinfrastructure, the AI module 104 can generate source code 102 to obtainthe data from the cached sources so as to limit network traffic fromexternal sources.

In a variety of embodiments, the AI module 104 can utilize theproduction metrics 154 when automatically generating the source code 102by modifying any software templates 138 to apply its learning about thecompany or institution backend infrastructure from the productionmetrics 154. For example, if software templates 138 are used that havecertain variables or parameters that control certain functionality ofthe company infrastructure, the AI module 104 can adjust the variablesor parameters to further optimize and customize the software templates138 based on the production metrics 154, to provide a more optimizedsource code 102 for the software application. For example, assume asoftware application is to be developed that functions to control memoryallocation in a server. If the software templates 138 used by the AImodule 104 implement such a function, and the production metrics 154indicate that the backend system has extra memory or storagecapabilities, the AI module 104 can generate a source code 102 based onthe software templates 138, allowing for use of this extra memory orstorage capability. This can be done by modifying, in the softwaretemplates 138, any variables or parameters that control this memoryallocation functionality. The modified software templates 138 can thenbe used as the source code 102. In a variety of embodiments, thismodified source code 102 may be stored and used to train the AI module104 for future use when future software applications being developedrequire the same (or similar) functionality and when the same conditionsfor the backend systems exist.

Continuing with the example, in a variety of embodiments, the productioninputs 112, similar to the application specific inputs 106, may beobtained from computer readable data files, such as a text file or aXML, data file, or from a repository or storage location where theproduction inputs 112 are stored. In a variety of embodiments, theproduction inputs 112 can further be transmitted to the AI module 104via the computer readable data files, the storage location, or therepository, and may be used for further processing by the AI module 104.

As previously mentioned, the revisions 110 refer to modifications madeby users of the system 100 to the source code 102 generated by the AImodule 104. In a variety of embodiments, the users may be thedevelopment team 118. The revisions 110 are made after the AI module 104generates the source code 102. For example, after the AI module 104generates the source code 102, the source code 102 may be transmitted tothe development team 118. The development team 118 can review the sourcecode 102 and further revise the source code 102 as needed to meet therequirements of the application specific inputs 106. If revisions 110are made, the software development team 118 can transmit the revisedsource code back to the AI module 104 so that the revised source codemay be analyzed by the AI module 104. This analyzing can include atleast the AI module 104 determining a difference between the source code102 generated and the revised source code. Based on this determination,the AI module 104 can determine, as part of its training, how therevisions 110 have modified the source code 102 originally generated. Ina variety of embodiments, the system 100 can store the revised sourcecode 102, similar to what was described above, for future use whenapplication specific inputs 106 for future software applications requirethe same functionality. As a result, the AI module 104 can generate amemory of revised source code that it can search for via the lookuptables every time the functionalities for software applications arerequested via application specific inputs 106. In a variety ofembodiments, rather than having the development team 118 transmit themodified source code 102 with the revisions 110 to the AI module 104,the AI module 104 can monitor the changes made by the development team118 automatically to determine the revisions 110 by implementing amonitoring function that logs keystrokes of the development team 118 torecognize the revisions 110 made.

FIG. 2 shows an example control flow 200 of the AI module 104 inaccordance with a number of embodiments of the present disclosure. In avariety of embodiments, the control flow 200 may be implemented bymodules and sub-modules. For example, the AI module 104 may include anapplication input module 202, a revision input module 204, a machinelearning module 206, a production input module 208, an external inputmodule 210, and a training module 212. In a variety of embodiments, themachine learning module 206 can couple to the application input module202, the revision input module 204, the production input module 208, theexternal input module 210, and the training module 212.

In a variety of embodiments, the machine learning module 206 canimplement the machine learning model that performs the processesdescribed above with respect to AI module 104 of FIG. 1 . For example,the machine learning module 206 can implement the table lookup functionsto search for and match the software templates 138 to the applicationspecific inputs 106. In a variety of embodiments, the searching may bedone on a database 214 storing the software templates 138. The machinelearning module 206 can further generate the source code 102 based onthe table lookup and/or perform the modifications to the softwaretemplates 138 based on the inputs, for example the production inputs112, as described with respect to FIG. 1 .

In a variety of embodiments, the machine learning module 206 can receiveinputs from the application input module 202, the revision input module204, the production input module 208, and the external input module 210,each of which can serve as interfaces for receiving the applicationspecific inputs 106, the revisions 110, the production inputs 112, andthe external inputs 108.

In a variety of embodiments, the training module 212 can couple to themachine learning module 206 and, either by itself or in conjunction withthe machine learning module 206, enable the training or learningcapabilities of the machine learning model. For example, the trainingmodule 212 can enable the determining of the difference between thesource code 102 generated by the machine learning module 206 and therevised source code provided by the development team 118, as describedwith respect to FIG. 1 . For example, in a variety of embodiments, thetraining module 212 can receive the source code 102 generated by themachine learning module 206 and further receive the revisions 110 viathe machine learning module 206, the revision input module 204, or acombination thereof. Based on the receipt, the training module 212 canimplement the functions necessary to determine the difference betweenthe source code 102 and the revisions 110. For example, it can do acompare function between the two source codes and determine thedifferences. The training module 212 can further store the differencesalong with the application specific inputs 106 for the softwareapplication in a database 214, in the same way as was described withrespect to FIG. 1 , for future use and search by the machine learningmodule 206 when automatically generating source code 102 for futuresoftware applications.

The modules described in FIGS. 1-2 may be implemented as instructionsstored on a non-transitory computer readable medium to be executed byone or more computing units such as a processor, a special purposecomputer, an integrated circuit, integrated circuit cores, or acombination thereof. The non-transitory computer readable medium may beimplemented with any number of memory units, such as a volatile memory,a nonvolatile memory, an internal memory, an external memory, or acombination thereof. The non-transitory computer readable medium may beintegrated as a part of the system 100 or installed as a removableportion of the system 100.

It has been discovered that the processes and system 100 described abovesignificantly improve the state of the art from previous systems becauseit introduces a novel way to generate source code 102 based on variousinputs including at least application specific inputs 106, revisions110, production inputs 112, and external inputs 108 to account for thevarious constraints and requirements on a software application beingdeveloped. It has been further discovered that the system 100significantly improves the art because it saves development time indeveloping software applications because it generates source code 102that would otherwise have to be written from scratch each time asoftware application is to be developed.

It has been further discovered that the system 100 significantlyimproves the art by automatically generating highly efficient andquality source code 102 by leveraging machine learning techniques thatuse feedback, such as the revisions 110, to learn how source code 102must be modified for future use to fit the specific needs of softwareapplications. It has been further discovered that the system 100significantly improves the art because it allows the consideration anduse of production inputs 112 to obtain valuable insights as to howexisting software applications perform in a production environment, andadjusts source code 102 to be optimized to the production environment.

It has been further discovered that the system 100 significantlyimproves the art because by considering the revisions 110, it can reducethe learning time of the machine learning model, because rather thanguessing how the source code 102 should be generated, the system 100 canobtain the correct source code via the revisions 110 and learn from therevised code how to generate source code 102 for future softwareapplications. It has been further discovered that the system 100significantly improves the art by allowing source code 102 to begenerated that is consistent with the rules and standards of a companyor institution and significantly improves the uniformity of code acrossthe organization through the use of software templates 138.

Methods of Operation

FIG. 3 shows an example method 300 of operating the system 100 inaccordance with a variety of embodiments of the present disclosure. Themethod 300 receives one or more application specific inputs 106 and oneor more external inputs 108, as shown in 302. For example, the one ormore application specific inputs 106 and the one or more external inputs108 can be received by the application input module 202 and the externalinput module 210. Method 300 can further automatically generate, with amachine learning model, source code 102 based on the one or moreapplication specific inputs 106 and the one or more external inputs 108,wherein the source code 102 embodies the one or more applicationspecific inputs 106 and the one or more external inputs 108, as shown in304. For example, the machine learning module 206 can implement themachine learning model and automatically generate the source code 102.Method 300 can further receive, by the one or more computing devices,one or more revisions 110 to the source code 102 automaticallygenerated, as shown in 306. For example, the one or more revisions 110can be received by the revision input module 204. Method 300 furtherdetermines, by the one or more computing devices, a difference betweenthe source code 102 generated and the source code 102 revised, as shownin 308. For example, the difference can be determined by the trainingmodule 212. Method 300 further trains, by the one or more computingdevices, the machine learning model to generate a future source codebased on the difference, as shown in 310. For example, training can bedone by the training module 212.

The operations of method 300 are performed, for example, by system 100,in accordance with embodiments described above.

Components of the System

FIG. 4 shows an example architecture 400 of the components implementingthe system 100 in a variety of embodiments of the present disclosure. Ina variety of embodiments, the components may include a control unit 402,a storage unit 406, a communication unit 416, and a user interface 412.The control unit 402 may include a control interface 404. The controlunit 402 may execute a software 410 to provide some or all of theintelligence of the system 100. The control unit 402 may be implementedin a number of different ways. For example, the control unit 402 may bea processor, an application specific integrated circuit (ASIC), anembedded processor, a microprocessor, a hardware control logic, ahardware finite state machine (FSM), a digital signal processor (DSP), afield programmable gate array (FPGA), or a combination thereof.

The control interface 404 may be used for communication between thecontrol unit 402 and other functional units or devices of the system100. The control interface 404 may also be used for communication thatis external to the functional units or devices of the system 100. Thecontrol interface 404 may receive information from the functional unitsor devices of the system 100, or from remote devices 420, or maytransmit information to the functional units or devices of the system100 or to remote devices 420. The remote devices 420 refer to units ordevices external to the system 100.

The control interface 404 may be implemented in different ways and mayinclude different implementations depending on which functional units ordevices of the system 100 or remote devices 420 are being interfacedwith the control unit 402. For example, the control interface 404 may beimplemented with a pressure sensor, an inertial sensor, amicroelectromechanical system (MEMS), optical circuitry, waveguides,wireless circuitry, wireline circuitry to attach to a bus, anapplication programming interface, or a combination thereof. The controlinterface 404 may be connected to a communication infrastructure 422,such as a bus, to interface with the functional units or devices of thesystem 100 or remote devices 420.

The storage unit 406 may store the software 410. For illustrativepurposes, the storage unit 406 is shown as a single element, although itis understood that the storage unit 406 may be a distribution of storageelements. Also for illustrative purposes, the storage unit 406 is shownas a single hierarchy storage system, although it is understood that thestorage unit 406 may be in a different configuration. For example, thestorage unit 406 may be formed with different storage technologiesforming a memory hierarchical system including different levels ofcaching, main memory, rotating media, or off-line storage. The storageunit 406 may be a volatile memory, a nonvolatile memory, an internalmemory, an external memory, or a combination thereof. For example, thestorage unit 406 may be a nonvolatile storage such as nonvolatile randomaccess memory (NVRAM), Flash memory, disk storage, or a volatile storagesuch as static random access memory (SRAM) or dynamic random accessmemory (DRAM). The database 214 may be implemented with the sametechnologies as the storage unit 406.

The storage unit 406 may include a storage interface 408. The storageinterface 408 may be used for communication between the storage unit 406and other functional units or devices of the system 100. The storageinterface 408 may also be used for communication that is external to thesystem 100. The storage interface 408 may receive information from theother functional units or devices of the system 100 or from remotedevices 420, or may transmit information to the other functional unitsor devices of the system 100 or to remote devices 420. The storageinterface 408 may include different implementations depending on whichfunctional units or devices of the system 100 or remote devices 420 arebeing interfaced with the storage unit 406. The storage interface 408may be implemented with technologies and techniques similar to theimplementation of the control interface 404.

The communication unit 416 may enable communication to devices,components, modules, or units of the system 100 or to remote devices420. For example, the communication unit 416 may permit the system 100to communicate with the development team 118, or to transmit data to andfrom the various modules of the system 100. The communication unit 416may further permit the devices of the system 100 to communicate withremote devices 420 such as an attachment, a peripheral device, or acombination thereof through a communication path 424, such as a wirelessor wired network.

The communication path 424 may span and represent a variety of networksand network topologies. For example, the communication path 424 may be apart of a wireless communication, wired communication, opticalcommunication, ultrasonic communication, or a combination thereof. Forexample, satellite communication, cellular communication, Bluetooth,Infrared Data Association standard (IrDA), wireless fidelity (WiFi), andworldwide interoperability for microwave access (WiMAX) are examples ofwireless communication that may be included in the communication path424. Cable, Ethernet, digital subscriber line (DSL), fiber optic lines,fiber to the home (FTTH), and plain old telephone service (POTS) areexamples of wired communication that may be included in thecommunication path 424. Further, the communication path 424 may traversea number of network topologies and distances. For example, thecommunication path 424 may include direct connection, personal areanetwork (PAN), local area network (LAN), metropolitan area network(MAN), wide area network (WAN), or a combination thereof.

The communication unit 416 may also function as a communication huballowing the system 100 to function as part of the communication path424 and not be limited to be an end point or terminal unit to thecommunication path 424. The communication unit 416 may include activeand passive components, such as microelectronics or an antenna, forinteraction with the communication path 424.

The communication unit 416 may include a communication interface 418.The communication interface 418 may be used for communication betweenthe communication unit 416 and other functional units or devices of thesystem 100 or to remote devices 420. The communication interface 418 mayreceive information from the other functional units or devices of thesystem 100, or from remote devices 420, or may transmit information tothe other functional units or devices of the system 100 or to remotedevices 420. The communication interface 418 may include differentimplementations depending on which functional units or devices are beinginterfaced with the communication unit 416. The communication interface418 may be implemented with technologies and techniques similar to theimplementation of the control interface 404.

The user interface 412 may present information generated by the system100. In a variety of embodiments, the user interface 412 allows a userof the system 100 to interface with the devices of the system 100 orremote devices 420. The user interface 412 may include an input deviceand an output device. Examples of the input device of the user interface412 may include a keypad, buttons, switches, touchpads, soft-keys, akeyboard, a mouse, or any combination thereof to provide data andcommunication inputs. Examples of the output device may include adisplay interface 414. The control unit 402 may operate the userinterface 412 to present information generated by the system 100. Thecontrol unit 402 may also execute the software 410 to presentinformation generated by the system 100, or to control other functionalunits of the system 100. The display interface 414 may be any graphicaluser interface such as a display, a projector, a video screen, or anycombination thereof.

The above detailed description and embodiments of the disclosed system100 are not intended to be exhaustive or to limit the disclosed system100 to the precise form disclosed above. While specific examples for thesystem 100 are described above for illustrative purposes, variousequivalent modifications are possible within the scope of the disclosedsystem 100, as those skilled in the relevant art will recognize. Forexample, while processes and methods are presented in a given order,alternative implementations may perform routines having steps, or employsystems having processes or methods, in a different order, and someprocesses or methods may be deleted, moved, added, subdivided, combined,or modified to provide alternative or sub-combinations. Each of theseprocesses or methods may be implemented in a variety of different ways.Also, while processes or methods are at times shown as being performedin series, these processes or blocks may instead be performed orimplemented in parallel and/or may be performed at different times.

The resulting methods, process, apparatus, device, product, and system100 is cost-effective, highly versatile, and accurate, and may beimplemented by adapting components for ready, efficient, and economicalmanufacturing, application, and utilization. Another important aspect ofthe present disclosure is that it valuably supports and services thehistorical trend of reducing costs, simplifying systems, and increasingperformance.

These and other valuable aspects of the embodiments of the presentdisclosure consequently further the state of the technology to at leastthe next level. While the disclosed embodiments have been described asthe best mode of implementing the system 100, it is to be understoodthat many alternatives, modifications, and variations will be apparentto those skilled in the art in light of the descriptions herein.Accordingly, it is intended to embrace all such alternatives,modifications, and variations that fall within the scope of the includedclaims. All matters set forth herein or shown in the accompanyingdrawings are to be interpreted in an illustrative and non-limitingsense. Accordingly, the scope of the invention should be determined notby the embodiments illustrated, but by the appended claims and theirequivalents.

What is claimed is:
 1. A computer implemented method for generatingsource code, the method comprising: receiving, by one or more computingdevices, one or more application specific inputs; automaticallygenerating, by the one or more computing devices and using a machinelearning model, source code embodying the one or more applicationspecific inputs based on: matching the one or more application specificinputs to descriptions or parameters of software templates, determiningwhether the descriptions or parameters of the software templatesindicate that the software templates perform functions required by theone or more application specific inputs, if it is determined that any ofthe software templates perform the functions required by the one or moreapplication specific inputs, copying the software templates as thesource code, and if it is determined no software templates perform thefunctions required by the one or more application specific inputs,copying the source code from the software templates matching closest infunction to the functions required by the one or more applicationspecific inputs as the source code.
 2. The computer implemented methodof claim 1, wherein the matching of the one or more application specificinputs to the descriptions or parameters of the software templates isperformed using a natural language processing (NLP) method, wherein theNLP method parses a textual description of the software templates andmatches the textual description to the one or more application specificinputs.
 3. The computer implemented method of claim 1, furthercomprising matching, by the one or more computing devices, the one ormore application specific inputs to the software templates using machinelearning classifier architectures trained to recognize patterns ofapplication specific inputs and match the patterns to the softwaretemplates.
 4. The computer implemented method of claim 1, furthercomprising: tracking, by the one or more computing devices,modifications to the source code; and storing, by the one or morecomputing devices, the modifications to the source code as a furthersoftware template; and utilizing the further software template as partof the software templates when generating a further source code.
 5. Thecomputer implemented method of claim 4, wherein the tracking of themodifications to the source code is performed by monitoring, by the oneor more computing devices, keystrokes indicating changes to the sourcecode.
 6. The computer implemented method of claim 1, further comprising:receiving, by the one or more computing devices, one or more externalinputs; and generating, by the one or more computing devices, the sourcecode embodying the one or more external inputs.
 7. The computerimplemented method of claim 1, further comprising: receiving, by the oneor more computing devices, one or more production inputs; andgenerating, by the one or more computing devices, the source codeembodying the one or more production inputs.
 8. A non-transitorycomputer readable medium including instructions for generating sourcecode that, when executed by a computing system, cause the computingsystem to perform operations comprising: receiving, by one or morecomputing devices, one or more application specific inputs;automatically generating, by the one or more computing devices and usinga machine learning model, source code embodying the one or moreapplication specific inputs based on: matching the one or moreapplication specific inputs to descriptions or parameters of softwaretemplates, determining whether the descriptions or parameters of thesoftware templates indicate that the software templates performfunctions required by the one or more application specific inputs, if itis determined that any of the software templates perform the functionsrequired by the one or more application specific inputs, copying thesoftware templates as the source code, and if it is determine nosoftware templates perform the functions required by the one or moreapplication specific inputs, copying the source code from the softwaretemplates matching closest in function to the functions required by theone or more application specific inputs as the source code.
 9. Thenon-transitory computer readable medium of claim 8, wherein the matchingof the one or more application specific inputs to the descriptions orparameters of the software templates is performed using a naturallanguage processing (NLP) method, wherein the NLP method parses atextual description of the software templates and matches the textualdescription to the one or more application specific inputs.
 10. Thenon-transitory computer readable medium of claim 8, wherein theoperations further comprise matching, by the one or more computingdevices, the one or more application specific inputs to the softwaretemplates using machine learning classifier architectures trained torecognize patterns of application specific inputs and match the patternsto the software templates.
 11. The non-transitory computer readablemedium of claim 8, wherein the operations further comprise: tracking, bythe one or more computing devices, modifications to the source code; andstoring, by the one or more computing devices, the modifications to thesource code as a further software template; and utilizing the furthersoftware template as part of the software templates when generating afurther source code.
 12. The non-transitory computer readable medium ofclaim 11, wherein the tracking of the modifications to the source codeis performed by monitoring, by the one or more computing devices,keystrokes indicating changes to the source code.
 13. The non-transitorycomputer readable medium of claim 8, wherein the operations furthercomprise: receiving, by the one or more computing devices, one or moreexternal inputs; and generating, by the one or more computing devices,the source code embodying the one or more external inputs.
 14. Thenon-transitory computer readable medium of claim 8, wherein theoperations further comprise: receiving, by the one or more computingdevices, one or more production inputs; and generating, by the one ormore computing devices, the source code embodying the one or moreproduction inputs.
 15. A computing system for generating source codecomprising: a memory storing instructions; and a control unit, coupledto the memory, configured to process the stored instructions to: receiveone or more application specific inputs; automatically generate, using amachine learning model, source code embodying the one or moreapplication specific inputs based on steps comprising: match the one ormore application specific inputs to descriptions or parameters ofsoftware templates, determine whether the descriptions or parameters ofthe software templates indicate that the software templates performfunctions required by the one or more application specific inputs, if itis determined that any of the software templates perform the functionsrequired by the one or more application specific inputs, copy thesoftware templates as the source code, and if it is determined nosoftware templates perform the functions required by the one or moreapplication specific inputs, copy the source code from the softwaretemplates matching closest in function to the functions required by theone or more application specific inputs as the source code.
 16. Thecomputing system of claim 15, wherein the matching of the one or moreapplication specific inputs to the descriptions or parameters of thesoftware templates is performed using a natural language processing(NLP) method, wherein the NLP method parses a textual description of thesoftware templates and matches the textual description to the one ormore application specific inputs.
 17. The computing system of claim 15,wherein the control unit is further configured to match the one or moreapplication specific inputs to the software templates using machinelearning classifier architectures trained to recognize patterns ofapplication specific inputs and match the patterns to the softwaretemplates.
 18. The computing system of claim 15, wherein the controlunit is further configured to: track modifications to the source code;and transmit for storage the modifications to the source code as afurther software template; and utilize the further software template aspart of the software templates when generating a further source code.19. The computing system of claim 18, wherein the control unit isfurther configured to track the modifications to the source code bymonitoring keystrokes indicating changes to the source code.
 20. Thecomputing system of claim 15 wherein the control unit is furtherconfigured to: receive one or more external inputs or one or moreproduction inputs; and generate the source code embodying the one ormore external inputs or the one or more production inputs.